Test case reduction in application binary interface (ABI) compatibility testing

ABSTRACT

A method and a system of test case reduction in application binary interface (ABI) compatibility testing are provided. The computer-implemented method includes generating test cases consisting of called functions with random numbers and types of arguments, validating that the arguments are correctly passed to the called functions, and, where it is found that arguments are not correctly passed, iteratively narrowing down the set of arguments required to find the minimal number and types of arguments to demonstrate an error in the ABI implementation.

BACKGROUND

The subject matter disclosed herein generally relates to test casereduction and, more particularly, to test case reduction in ABIcompatibility testing.

Many operating systems include an Application Binary Interface (ABI)that defines the interface between a calling function and the functionthat is the target of the call. For example, the ABI may define whenarguments are passed in memory versus in registers for particular datatypes or data sizes. Errors can occur when a compiler is ported to a newoperating system and therefore needs to support a new ABI, or when a newcompiler is created for an existing operating system.

To ensure proper testing of the ABI a number of test cases can bewritten or automatically generated. The test cases are run to test andensure that all parameters and return arguments are passed correctlybetween the calling and called functions and can include a large varietyof parameters and return types. When an error is detected, it is oftenin a function containing a large number of randomized arguments, and itcan be a challenging and manual process to iteratively remove argumentsfrom the called function (on both the caller and callee side) until theminimal set of arguments that cause a failure are found. Without thisminimal set, it is very difficult for the developer to diagnose whataspect of the ABI the compiler has failed to correctly implement.

Further, current techniques for reducing the set of arguments to thosethat produce the error are time consuming because the removal process iscumbersome and the removal may change the underlying logic causingdetection errors. Specifically, when an argument is removed from thefunction, it is removed from at least three places: the function call inthe caller, the function definition in the callee, and the functiondeclaration in the header file. Additionally, when an argument isremoved, the logic of the function itself may change, and manual stepsmay be required to remove all uses of that argument from the calledfunction. Further, once all instances of the argument are removed fromthe called function, the logic of the function may change and theability of the function to validate that parameters were passedcorrectly is compromised, requiring further manual work to correct anyerrors.

Accordingly, test case reduction in ABI compatibility testing is desiredthrough a method and system of determining a minimal set of argumentsthat cause the event that the test case is testing for.

BRIEF DESCRIPTION

According to one embodiment, a computer-implemented method of test casereduction in application binary interface (ABI) compatibility testing isprovided. The computer-implemented method including receiving, from amemory at a processor, a failed test case and a plurality of argumentsthat were the cause of a failure of the failed test case, selecting,using the processor, a first subset of arguments from the plurality ofarguments, running, using the processor, a copy of the failed test casewithout the first subset of arguments, omitting, using the processor,the first subset of arguments from the copy of the failed test casebased on a determination that the copy of the failed test case continuesto fail, and retaining, using the processor, the first subset ofarguments based on a determination that the copy of the failed test casepasses indicating that the first subset of arguments contain argumentsthat trigger the failure.

In addition to one or more of the features described above, or as analternative, further embodiments may include iteratively selecting,using the processor, a plurality of subsets of the plurality ofarguments and omitting when the copy of the failed test case continuesto fail until all arguments in the plurality of arguments have beenscreened.

In addition to one or more of the features described above, or as analternative, further embodiments may include storing, in the memory, theremaining plurality of arguments that has arguments omitted as a minimalset of arguments that cause the failure of the failed test case.

In addition to one or more of the features described above, or as analternative, further embodiments may include generating, using theprocessor, a plurality of test cases that each include a function calland a target function, generating, using the processor, a plurality ofarguments for each of the plurality of test cases, executing, using theprocessor, the plurality of test cases using the plurality of arguments,detecting, using the processor, a set of failed test cases from theplurality of test cases, and selecting, using the processor, a failedtest case from the set of failed test cases.

In addition to one or more of the features described above, or as analternative, further embodiments may include generating the copy of thefailed test case based on a random number generator seeded by a seedvalue that was used to generate the failed test case initially.

In addition to one or more of the features described above, or as analternative, further embodiments may include detecting a randomlygenerated failed test case, receiving the seed value of the randomlygenerated failed test case, regenerating the failed test case using theseed value, and storing the regenerated failed test case as the copy ofthe failed test case in memory.

In addition to one or more of the features described above, or as analternative, further embodiments may include, wherein selecting thefirst subset of arguments from the plurality of arguments includesdefining a plurality of states of arguments, assigning each argument inthe plurality of arguments a state, and selecting the first subset ofarguments based on the state of each argument.

In addition to one or more of the features described above, or as analternative, further embodiments may include, wherein defining theplurality of states of arguments including defining an omit statewherein an argument is known not to be required to produce a failure,defining an inclusive state wherein an argument is known to be requiredto produce a failure, defining a test state wherein an argument in thisstate is to be tested as one possibly not required to produce a testcase failure, and defining an assumed inclusion state wherein anargument is assumed to be required to produce a failure.

In addition to one or more of the features described above, or as analternative, further embodiments may include, wherein defining theplurality of states of arguments further includes representing the omitstate by a first character, representing the inclusive state by a secondcharacter, representing the test state by a third character, andrepresenting the assumed inclusion state by a fourth character.

According to another embodiment, a computer program product for testcase reduction in application binary interface (ABI) compatibilitytesting is provided. The computer program product including a computerreadable storage medium having program instructions embodied therewith.The program instructions executable by a processor to cause theprocessor to receive, from a memory at a processor, a failed test caseand a plurality of arguments that were the cause of a failure of thefailed test case, select, using the processor, a first subset ofarguments from the plurality of arguments, run, using the processor, acopy of the failed test case without the first subset of arguments,omit, using the processor, the first subset of arguments from the copyof the failed test case based on a determination that the copy of thefailed test case continues to fail, and retain, using the processor, thefirst subset of arguments based on a determination that the copy of thefailed test case passes indicating that the first subset of argumentscontain arguments that trigger the failure.

In addition to one or more of the features described above, or as analternative, further embodiments may include program instructionsexecutable by the processor to cause the processor to iterativelyselect, using the processor, a plurality of subsets of the plurality ofarguments and omitting when the copy of the failed test case continuesto fail until all arguments in the plurality of arguments have beenscreened.

In addition to one or more of the features described above, or as analternative, further embodiments may include program instructionsexecutable by the processor to cause the processor to store, in thememory, the remaining plurality of arguments that has arguments omittedas a minimal set of arguments that cause the failure of the failed testcase.

In addition to one or more of the features described above, or as analternative, further embodiments may include program instructionsexecutable by the processor to cause the processor to generate, usingthe processor, a plurality of test cases that each include a functioncall and a target function, generate, using the processor, a pluralityof arguments for each of the plurality of test cases, execute, using theprocessor, the plurality of test cases using the plurality of arguments,detect, using the processor, a set of failed test cases from theplurality of test cases, and select, using the processor, a failed testcase from the set of failed test cases.

In addition to one or more of the features described above, or as analternative, further embodiments may include program instructionsexecutable by the processor to cause the processor to generate the copyof the failed test case based a random number generator seeded by a seedvalue that was used to generate the failed test case initially.

In addition to one or more of the features described above, or as analternative, further embodiments may include program instructionsexecutable by the processor to cause the processor to detect a randomlygenerated failed test case, receive the seed value of the randomlygenerated failed test case, regenerate the failed test case using theseed value, and store the regenerated failed test case as the copy ofthe failed test case in memory.

In addition to one or more of the features described above, or as analternative, further embodiments may include program instructionsexecutable by the processor to cause the processor to define a pluralityof states of arguments, assign each argument in the plurality ofarguments a state, and select the first subset of arguments based on thestate of each argument.

In addition to one or more of the features described above, or as analternative, further embodiments may include program instructionsexecutable by the processor to cause the processor to define an omitstate wherein an argument is known not to be required to produce afailure, define an inclusive state wherein an argument is known to berequired to produce a failure, define a test state wherein an argumentin this state is to be tested as one possibly not required to produce atest case failure, and define an assumed inclusion state wherein anargument is assumed to be required to produce a failure.

In addition to one or more of the features described above, or as analternative, further embodiments may include program instructionsexecutable by the processor to cause the processor to represent the omitstate by a first character, represent the inclusive state by a secondcharacter, represent the test state by a third character, and representthe assumed inclusion state by a fourth character.

According to another embodiment, a system for test case reduction inapplication binary interface (ABI) compatibility testing is provided.The system including a memory having computer readable instructions, anda processor configured to execute the computer readable instructions,the computer readable instructions including receiving, from the memoryat the processor, a failed test case and a plurality of arguments thatwere the cause of a failure of the failed test case, selecting, usingthe processor, a first subset of arguments from the plurality ofarguments, running, using the processor, a copy of the failed test casewithout the first subset of arguments, omitting, using the processor,the first subset of arguments from the copy of the failed test casebased on a determination that the copy of the failed test case continuesto fail, and retaining, using the processor, the first subset ofarguments based on a determination that the copy of the failed test casepasses indicating that the first subset of arguments contain argumentsthat trigger the failure.

In addition to one or more of the features described above, or as analternative, further embodiments may include a computer readable programincluding iteratively selecting, using the processor, a plurality ofsubsets of the plurality of arguments and omitting when the copy of thefailed test case continues to fail until all arguments in the pluralityof arguments have been screened.

The foregoing features and elements may be combined in variouscombinations without exclusivity, unless expressly indicated otherwise.These features and elements as well as the operation thereof will becomemore apparent in light of the following description and the accompanyingdrawings. It should be understood, however, that the followingdescription and drawings are intended to be illustrative and explanatoryin nature and non-limiting.

BRIEF DESCRIPTION OF THE DRAWINGS

The foregoing and other features, and advantages of the presentdisclosure are apparent from the following detailed description taken inconjunction with the accompanying drawings in which:

FIG. 1 depicts a block diagram of a computer system for implementingsome or all aspects of the system, according to some embodiments;

FIG. 2 is a flowchart of a method of test case reduction in accordancewith one or more embodiments;

FIG. 3 is a flowchart of a subroutine used in a method of test casereduction in accordance with one or more embodiments; and

FIG. 4 is a diagram of a method of test case reduction in accordancewith one or more embodiments.

DETAILED DESCRIPTION

As shown and described herein, various features of the disclosure willbe presented. Various embodiments may have the same or similar featuresand thus the same or similar features may be labeled with the samereference numeral, but preceded by a different first number indicatingthe figure to which the feature is shown. Thus, for example, element “a”that is shown in FIG. X may be labeled “Xa” and a similar feature inFIG. Z may be labeled “Za.” Although similar reference numbers may beused in a generic sense, various embodiments will be described andvarious features may include changes, alterations, modifications, etc.as will be appreciated by those of skill in the art, whether explicitlydescribed or otherwise would be appreciated by those of skill in theart.

Embodiments described herein are directed to taking a failing test casethat was produced by a test case generator, and automatically narrowingit down to the smallest set of source code instructions, and thesmallest set of function arguments, required to produce a failure.

Specifically, embodiments described herein are directed to a method anda system of test case reduction in application binary interface (ABI)compatibility testing. The computer-implemented method includesgenerating test cases consisting of called functions with random numbersand types of arguments, validating that the arguments are correctlypassed to the called functions, and, where it is found that argumentsare not correctly passed, recursively narrowing down the set ofarguments required to find the minimal number and types of arguments todemonstrate an error in the ABI implementation

For example, according to one or more other embodiments of the presentdisclosure, a method of test case reduction in an ABI is provided asfollows. Initially, a test case generator generates large volumes offunction calls, from a main function stored in one source file, tofunctions in another file. The generator also generates the logic in thecalled function that reads the passed in arguments, performs somecomputations (to prevent a compiler optimizer from ignoring argumentcontents, thus potentially missing an argument passing error), andreturns a result. That same logic is placed in the main function so thatthe final computation in the main and called functions can be compared.If these two final computations are identical, it is assumed allarguments were passed correctly. If the two computations do not match,the main function prints an error message showing the disparate results.

According to one or more embodiments, once testing has revealed aproblem, the test case generator can regenerate only the single functioncall in main, and the single function, where the failure occurred, tovalidate that the failure occurs with just that one function (in somecases, the problem may only occur if a previous function was calledfirst).

-   -   Once the tester or automated test harness has confirmed that the        single call produces the error, the test case generator can        iteratively generate new versions of the same function call in        main, and called function, in which selective arguments are        omitted from both the function argument list, and from the logic        of the main and called functions, until the minimal set of        arguments is found that exposes the ABI problem.

Turning now to FIG. 1, an electronic computing device 100, which mayalso be called a computer system 100, that includes a plurality ofelectronic computing device sub-components is generally shown inaccordance with one or more embodiments. Particularly, FIG. 1illustrates a block diagram of a computer system 100 (hereafter“computer 100”) for use in practicing the embodiments described herein.The methods described herein can be implemented in hardware, software(e.g., firmware), or a combination thereof. In an exemplary embodiment,the methods described herein are implemented in hardware, and may bepart of the microprocessor of a special or general-purpose digitalcomputer, such as a personal computer, workstation, minicomputer, ormainframe computer. Computer 100 therefore can embody a general-purposecomputer. In another exemplary embodiment, the methods described hereinare implemented as part of a mobile device, such as, for example, amobile phone, a personal data assistant (PDA), a tablet computer, etc.

In an exemplary embodiment, in terms of hardware architecture, as shownin FIG. 1, the computer 100 includes processor 101. Computer 100 alsoincludes memory 102 coupled to processor 101, and one or more inputand/or output (I/O) adaptors 103, that may be communicatively coupledvia a local system bus 105. Communications adaptor 104 may beoperatively connect computer 100 to one or more networks 111. System bus105 may also connect one or more user interfaces via interface adaptor112. Interface adaptor 112 may connect a plurality of user interfaces tocomputer 100 including, for example, keyboard 109, mouse 120, speaker113, etc. System bus 105 may also connect display adaptor 116 anddisplay 117 to processor 101. Processor 101 may also be operativelyconnected to graphical processing unit 118.

Further, the computer 100 may also include a sensor 119 that isoperatively connected to one or more of the other electronicsub-components of the computer 100 through the system bus 105. Thesensor 119 can be an integrated or a standalone sensor that is separatefrom the computer 100 and may be communicatively connected using a wireor may communicate with the computer 100 using wireless transmissions.

Processor 101 is a hardware device for executing hardware instructionsor software, particularly that stored in a non-transitorycomputer-readable memory (e.g., memory 102). Processor 101 can be anycustom made or commercially available processor, a central processingunit (CPU), a plurality of CPUs, for example, CPU 101 a-101 c, anauxiliary processor among several other processors associated with thecomputer 100, a semiconductor based microprocessor (in the form of amicrochip or chip set), a macroprocessor, or generally any device forexecuting instructions. Processor 101 can include a memory cache 106,which may include, but is not limited to, an instruction cache to speedup executable instruction fetch, a data cache to speed up data fetch andstore, and a translation lookaside buffer (TLB) used to speed upvirtual-to-physical address translation for both executable instructionsand data. The cache 106 may be organized as a hierarchy of more cachelevels (L1, L2, etc.).

Memory 102 can include random access memory (RAM) 107 and read onlymemory (ROM) 108. RAM 107 can be any one or combination of volatilememory elements (e.g., DRAM, SRAM, SDRAM, etc.). ROM 108 can include anyone or more nonvolatile memory elements (e.g., erasable programmableread only memory (EPROM), flash memory, electronically erasableprogrammable read only memory (EEPROM), programmable read only memory(PROM), tape, compact disc read only memory (CD-ROM), disk, cartridge,cassette or the like, etc.). Moreover, memory 102 may incorporateelectronic, magnetic, optical, and/or other types of non-transitorycomputer-readable storage media. Note that the memory 102 can have adistributed architecture, where various components are situated remotefrom one another, but can be accessed by the processor 101.

The instructions in memory 102 may include one or more separateprograms, each of which comprises an ordered listing ofcomputer-executable instructions for implementing logical functions. Inthe example of FIG. 1, the instructions in memory 102 may include asuitable operating system 110. Operating system 110 can control theexecution of other computer programs and provides scheduling,input-output control, file and data management, memory management, andcommunication control and related services.

Specifically, the operating system 110 can include an Application BinaryInterface (ABI) that defines the interface between a calling functionand the function that is the target of the call. For example, the ABImay define when arguments are passed in memory versus in registers forparticular data types or data sizes.

Input/output adaptor 103 can be, for example but not limited to, one ormore buses or other wired or wireless connections, as is known in theart. The input/output adaptor 103 may have additional elements, whichare omitted for simplicity, such as controllers, buffers (caches),drivers, repeaters, and receivers, to enable communications. Further,the local interface may include address, control, and/or dataconnections to enable appropriate communications among theaforementioned components.

Interface adaptor 112 may be configured to operatively connect one ormore I/O devices to computer 100. For example, interface adaptor 112 mayconnect a conventional keyboard 109 and mouse 120. Other output devices,e.g., speaker 113 may be operatively connected to interface adaptor 112.Other output devices may also be included, although not shown. Forexample, devices may include but are not limited to a printer, ascanner, microphone, and/or the like. Finally, the I/O devicesconnectable to interface adaptor 112 may further include devices thatcommunicate both inputs and outputs, for instance but not limited to, anetwork interface card (NIC) or modulator/demodulator (for accessingother files, devices, systems, or a network), a radio frequency (RF) orother transceiver, a telephonic interface, a bridge, a router, and thelike.

Computer 100 can further include display adaptor 116 coupled to one ormore displays 117. In an exemplary embodiment, computer 100 can furtherinclude communications adaptor 104 for coupling to a network 111.

Network 111 can be an IP-based network for communication betweencomputer 100 and any external device. Network 111 transmits and receivesdata between computer 100 and external systems. In an exemplaryembodiment, network 111 can be a managed IP network administered by aservice provider. Network 111 may be implemented in a wireless fashion,e.g., using wireless protocols and technologies, such as WiFi, WiMax,etc. Network 111 can also be a packet-switched network such as a localarea network, wide area network, metropolitan area network, Internetnetwork, or other similar type of network environment. The network 111may be a fixed wireless network, a wireless local area network (LAN), awireless wide area network (WAN) a personal area network (PAN), avirtual private network (VPN), intranet or other suitable networksystem.

If computer 100 is a PC, workstation, laptop, tablet computer and/or thelike, the instructions in the memory 102 may further include a basicinput output system (BIOS) (omitted for simplicity). The BIOS is a setof essential routines that initialize and test hardware at startup,start operating system 110, and support the transfer of data among theoperatively connected hardware devices. The BIOS is stored in ROM 108 sothat the BIOS can be executed when computer 100 is activated. Whencomputer 100 is in operation, processor 101 may be configured to executeinstructions stored within the memory 102, to communicate data to andfrom the memory 102, and to generally control operations of the computer100 pursuant to the instructions.

According to one or more embodiments, the electronic computing device100 includes the operating system 110 that can include the ApplicationBinary Interface (ABI) that defines the interface between a callingfunction and the function that is the target of the call. For example,the ABI may define when arguments are passed in memory 102 versus inregisters, which may be located in the cache 106, for particular datatypes or data sizes. As noted above, proper testing of the ABI in theoperating system 110 is provided by implementing a plurality of testcases that are each provided with a plurality of arguments. Then when atest case fails, additional processing as provided in the embodimentsdisclosed herein allows for a reduction of the arguments to the minimalset that cause the failure of the test case. Specific examples of thisare provided in the following figures and specification.

For example, turning now to FIG. 2, this figure is a flowchart of amethod of test case reduction is shown in accordance with one or moreembodiments of this disclosure.

The method call 202 for the method used to obtain the minimal set ofpassing arguments is titled “FindWorkingPattern” 202. FindWorkingPatterncan be a function to determine the minimum set of required arguments toproduce a failure. The input arguments to this method include acharacter array “range”, and two integers, lower and higher.

The character array “range”, consists of one character per argument inthe original test case function. Each position in range can contain oneof four characters: “−”, meaning the argument is known not to berequired to produce a failure; “+”, meaning the argument is known to berequired to produce a failure; “?”, meaning the argument is being testedas one possibly not required to produce a failure; and“!”, meaning theargument is assumed to be required to produce a failure.

The two integers, lower and higher, identify the first position in rangeto check, and the first position after the checked area (i.e. theelement after the highest element to check).

The method can begin by checking if the lower integer value is greaterthan the higher integer value 203, and if the lower integer is greater,then a return from the function follows as there is nothing to test. Ifthere are values to test then the methods moves on to operation 204.Specifically, if the lower value is equal to the higher integer value203, then the method sets the element at range[lower] to “?” atoperation 205, which is a test to determine if the argument can beomitted.

The method next calls a “TestMatch” function 206 which provides anoutput of true or false depending if the test fails or passes. Forexample, “TestMatch” is a function that generates a new copy of the testcase using the test case random value seed already used to generate theoriginal test function, in which all “−” or “?” arguments are omittedand all other arguments are used when running the test. Next, based onthe output of “TestMatch” 207 if the test case fails, the method setsthat element to ‘-’ because it is known that it can be omitted 208.Otherwise the method sets that element to ‘+’ because it is known thatit is required 209.

Returning to operation 204, if the lower is at least one less thanhigher a midway value is calculated that is a midway point between lowerand higher 210. Further in this operation the operation also sets allcharacters in range from lower to midway (exclusive) to “?” and sets allcharacters in range from midway (inclusive) to higher (inclusive) to‘!’. Next the method again calls the testing function TestMatch 211providing the input of the current range values that need tested.Particularly the operation 212 generates a new copy of the test case inwhich all “−” or “?” arguments are omitted. If the test case fails thenthe method sets all characters in range from lower to midway (exclusive)to “−” because they are known not to be required for the test case tofail 213. Next the method recursively call findWorkingPattern with therange, providing midway as the lower value, and higher as the highervalue, and returns when done 214.

Otherwise if the test does not fail at operation 212 the method sets allcharacters in range from lower to midway (exclusive) to ‘!’ and sets allcharacters in range from midway (inclusive) to higher (inclusive) to ‘?’215. Next the method calls the TestMatch function 216 to test the testcase with the updated range values. Specifically, the TestMatch function216 generates a new copy of the test case in which all “−” or “?”arguments are omitted and runs the test returning an output thatindicates if the test case fails or passes.

If the test case fails the method sets all characters in range frommidway (inclusive) to higher (exclusive) to “−” because they are knownnot to be required 218. Next, the method recursively callsfindWorkingPattern 219 with the range as the input, providing lower asthe lower value, and midway as the higher value, and returns when done.

Otherwise, when the test case testing does not fail at 217, thisindicates that there are arguments in each of (lower, midway−1) and(midway, higher−1) that are required, so the method sets all elementsfrom lower to higher to “!” 220, and calls findWorkingPattern twice (221and 222), once with lower and midway as the elements of range to test221, and once with midway and higher as the elements of range to test222.

According to one or more embodiments, the algorithm used to generate anABI test case allows for easy regeneration of the same test case, withthe same logic, except for that involving omitted arguments, bydistinguishing between a generated argument (pseudo-randomly produced)and an emitted argument (one that is emitted into the resulting testcase main and target functions).

For example, a specific embodiment of the algorithm used includes thefollowing operations. Initially a random number generator (RNG) isseeded with the function number, so that it reliably produces the samerandom outputs on each call to it (calls to the RNG are used todetermine number of arguments to generate, type of each argument, nameof each argument, other details of complex arguments such as structures,unions, or arrays, and logic used to compute results from arguments).

Further, according to one or more embodiments, in order to generate manydifferent test cases, a random number generator is used that istypically seeded at 0 at the start of test case generation. As eachadditional function is generated, the seed is incremented by 1, and therandom number generator is re-seeded, so that function 0 is generatedfrom a RNG seeded at 0, function 1 by a RNG seeded at 1, and so on. Areason for seeding in this way includes: 1) A large number of functionscan be generated together (function 0 . . . function 1000) and tested;2) when a given function, for example function 323, is found to fail, itcan be regenerated on its own, with 0 or more arguments omitted tonarrow down the minimal subset of failing arguments by passing in boththe seed (323) and the omit arguments.

Further, all arguments are generated within the test case generator eachtime, and all logic within the main function and the called function isgenerated within the test case generator each time.

Each programmatic statement is tested against the list of omittedarguments to determine if the statement should be emitted. Anyprogrammatic statement containing arguments that are omitted is notemitted, while any programmatic statement not containing arguments thatare omitted is emitted.

Further, FIG. 3 is a flowchart of a subroutine used in a method of testcase reduction in accordance with one or more embodiments of thisdisclosure. Specifically, the TestMatch function is shown which is usedin the above described method findWorkingPattern. This subroutine methodbegins by receiving the range to be tested 332. Next the subroutinegenerates a copy of the range and sets a counter to zero 333. Thesubroutine then looks at the data at position “i” in the copied rangeand changes to “?” 334, meaning the argument is being tested as onepossibly not required to produce a failure to “−” 335, meaning theargument is known not to be required to produce a failure. Further, thefunction changes “!” 336, meaning the argument is assumed to be requiredto produce a failure to “+” 337, meaning the argument is known to berequired to produce a failure. The subroutine method then increments thecounter “i” 338. Then the subroutine method checks to see if the counteris less than the length of the range 339 and if it is not it continuesto iterate through the copy of the range adjusting all argument with ‘?’to ‘−’ and ‘!’ to ‘+’ for test purposes (operations 334, 335, 336, and337). Once all arguments in the range copy are updated accordingly, thesubroutine method goes on to generate a test case with the ‘−’ argumentsomitted 340. Then the subroutine method runs the test case 341 andchecks to see if it passes 342. If the test case passes this subroutinemethod returns a false value 343 indicating the arguments omitted causethe failure and should remain included and if it does not pass itreturns a true value 344 indicating that the arguments omitted are notcausing the failure and can be omitted.

FIG. 4 is a flowchart of a method 400 of test case reduction inaccordance with one or more embodiments of this disclosure. The method400 includes receiving, from a memory at a processor, a failed test caseand a plurality of arguments that were the cause of a failure of thefailed test case (operation 405). The method 400 further includesselecting, using the processor, a first subset of arguments from theplurality of arguments (operation 410). The method 400 also includesrunning, using the processor, a copy of the failed test case without thefirst subset of arguments (operation 415). The method 400 includesomitting, using the processor, the first subset of arguments from thecopy of the failed test case based on a determination that the copy ofthe failed test case continues to fail (operation 420). Finally, themethod 400 includes retaining, using the processor, the first subset ofarguments based on a determination that the copy of the failed test casepasses indicating that the first subset of arguments contain argumentsthat trigger the failure (operation 425).

According to another embodiment, the method can further includerecursively selecting, using the processor, a plurality of subsets ofthe plurality of arguments and omitting when the copy of the failed testcase continues to fail until all arguments in the plurality of argumentshave been screened. The method can also further include storing, in thememory, the remaining plurality of arguments that has arguments omittedas a minimal set of arguments that cause the failure of the failed testcase.

According to another embodiment, the method can further includegenerating, using the processor, a plurality of test cases that eachinclude a function call and a target function, generating, using theprocessor, a plurality of arguments for each of the plurality of testcases, executing, using the processor, the plurality of test cases usingthe associated plurality of arguments, detecting, using the processor, aset of failed test cases from the executed plurality of test cases andselecting, using the processor, a failed test case from the set offailed test cases.

Further, according to another embodiment, the method can includegenerating the copy of the failed test case based on a seed valuecreated by a random number generator that was used to generate thefailed test case initially. This can further include detecting therandomly generated failed test case, receiving the seed value of therandomly generated failed test case, regenerating the failed test caseusing the seed value, and storing the regenerated failed test case asthe copy of the failed test case in memory.

According to another embodiment, selecting the first subset can furtherinclude defining a plurality of states of arguments, assigning eachargument in the plurality of arguments a state, and selecting the firstsubset of arguments based on the state of each argument. For example,according to an embodiment, the method can include defining an omitstate wherein an argument is known not to be required to produce afailure, and defining an inclusive state wherein an argument is known tobe required to produce a failure. Further, the method can includedefining a test state wherein an argument in this state is to be testedas one possibly not required to produce the test case failure, anddefining an assumed inclusion state wherein an argument is assumed to berequired to produce a failure.

According to one or more embodiments, each state can be represented byone or more characters. For example, the use of the characters ‘+’, ‘−’,‘?’, and ‘!’ can be used as the characters used to denote the fourstates (or according to an embodiment, representing the four states asparticular characters). The particular character or string of charactersused can be any combination of characters. Thus, the use of ‘+’, ‘−’,‘?’, and ‘!’ throughout the specification is done for simplicity ofexplanation but is not meant to limit the invention to these embodimentsas different characters can be used. For example, any characters couldbe used including numbers, letters, or other punctuation marks, or acombination thereof.

In the above embodiments characters were chosen for ease ofimplementation. According to other embodiments, an array of arbitrarytypes in which each element of the array denotes one of the fourpossible states can be used. Therefore, in accordance with otherembodiments, an array of integers, or a scalar integer or array ofintegers with sufficient bits to represent the number of states (4)times the number of arguments, could be used.

For example, according to an embodiment, the method can include definingan omit state indicated by a first character “−” wherein an argument isknown not to be required to produce a failure. According to otherembodiments this omit state could be represented using any othercharacter or chain of characters. The method further includes definingan inclusive state indicated by a second character “+” wherein anargument is known to be required to produce a failure. Further, themethod can include defining a test state indicated by a third character“?” wherein an argument in this state is to be tested as one possiblynot required to produce the test case failure, and defining an assumedinclusion state indicated by a fourth character “!” wherein an argumentis assumed to be required to produce a failure. The first, second,third, and fourth characters used to represent the states can be changedfor other characters or string of characters.

Advantageously, embodiments described herein provide a clear value addto the space of Application Binary Interface testing and have been shownin practice to reduce the time and cost to determine where a problem isand where it needs to be fixed. Currently, this is an exhaustive manualprocess.

While the present disclosure has been described in detail in connectionwith only a limited number of embodiments, it should be readilyunderstood that the present disclosure is not limited to such disclosedembodiments. Rather, the present disclosure can be modified toincorporate any number of variations, alterations, substitutions,combinations, sub-combinations, or equivalent arrangements notheretofore described, but which are commensurate with the scope of thepresent disclosure. Additionally, while various embodiments of thepresent disclosure have been described, it is to be understood thataspects of the present disclosure may include only some of the describedembodiments.

When developing an operating system a structure is provided that allowsprograms to have a variety of different procedures. For example aprogram can include work procedures that process inputs and providesubstantive outputs while other procedures are provided that call thework procedures and direct argument storage to and from the workprocedures. When calling a procedure, the procedure being called definesits interface including what argument inputs the procedure shouldreceive and what output a user can expect. Accordingly, a system isprovided for managing the movement of those arguments to and from theworking procedures. Further, in one or more embodiments, an ApplicationBinary Interface (ABI) is provided that defines where arguments getstored and passed through going to and from the called procedure and thecalling procedure.

Test procedures exist that are designed to test the calling proceduresand working procedures use of the ABI. The test procedure includesgenerating a number of random test cases that consist of code thatgenerates arguments of random types with random values along with thetesting commands.

The test procedure then tests using the generated test cases to see ifarguments are correctly received, generates a result, and then teststhat the correct result is returned. Typical functions receive, forexample four or five arguments, but testing, specifically limit testing,calls in test cases that include, for example, hundreds of arguments,and runs hundreds of such tests cases. This creates a challenge suchthat it is unclear which of the 100s of arguments having been providedwith the test case caused the test case to fail. Further a particularcombination and sequence of arguments can cause the failure as welladding to the complexity of detecting a minimal set of arguments thatcause a test case failure.

For example, according to one or more embodiments, a process for testcase reduction in application binary interface (ABI) compatibilitytesting can include the following specific operations, but is notlimited thereto. The process includes generating multiple sets of threefiles per set, by a test case generator, wherein the three filescomprise a header file containing declarations for all called functions,and declarations for all non-built-in data types (such as, for alanguage such as C++, classes, structures, and unions) that are usedboth on a caller side and a callee side. The process uses a main sourcefile containing a single main function, which in turn contains, for eachcalled function, definitions of any variables to be used in the calledfunction, logic to perform computations on arguments and obtain a finalresult value, a call to the called function with required arguments andvalidation that the called function returns a same value fromcomputations as a final result value computed in the main function. Theprocess also includes a target source file containing each calledfunction, including: a full argument list and return type. The processuses logic to perform computations on the arguments and obtain the finalresult value of the target source file, wherein computations areidentical to those performed in the main source file, and the resultvalue should be identical when all arguments were passed correctly, andwherein the generation is controlled by a random number generator,seeded with a predetermined value.

The process goes on to include compiling each file into an object file,and linking a main object file and a corresponding target object filetogether into an executable, wherein calls between the main object fileand the corresponding target object file are governed by the ABI.Further, the process includes executing each executable. For anyfunction call with a result that does not match the result computed inthe main function, the process includes printing a function name, andprinting the final result value computed in the main function andprinting the final result value computed in the target source file isalso included. Further the process includes regenerating test cases foreach individual function that is not correct, by specifying a seedcorresponding to that function name, and instructing the test casegenerator to generate a single function test case, wherein the testsystem validates that a same failure is observed with the single testcall. Finally, in response to the function continuing to fail in thesingle call case, the process includes adding an omit argument to thetest case generator, and indicating which arguments to omit, wherein thesingle call case is repeated until a minimal set of failing arguments isidentified.

According to one or more other embodiments, test cases are generated andrun while information is collected that, once processed, can indicate ifand what input or combination of argument inputs caused the test casefailure.

According to another example, and according to one or more embodiments,a test case generator generates multiple sets. According to oneembodiment the sets consist of three files per set. For example, the setof three files can includes (1) a header file containing declarationsfor all the called functions and declarations for all non-built-in datatypes (e.g. classes, structures, unions) that are used both on thecaller and callee side. The set of three files can also include (2) asource file containing a single main function, which in turn contains,for each called function: Definitions of any variables to be used in thecalled function; Logic to perform computations on the arguments andobtain a final result value; Call to the called function with therequired arguments; and Validation that the called function returns thesame value from computations as the final result value computed in main.The set of three files can also include (3) a source file containingeach called function, including: The full argument list and return type;Logic to perform computations on the arguments and obtain a final resultvalue. The computations are identical to those performed in main, andthe result value should be identical if all arguments were passedcorrectly.

According to one or more embodiments, the test case generation iscontrolled by a random number generator (RNG), which is seeded with avalue at the start (e.g. −−seed=123). An arbitrary number of functionsand function calls are generated for each test case. For each newfunction generated, the RNG is re-seeded with the next seed value(RNG.seed (++lastseed)). Each function name consists of “Func” plus theseed number.

According to one or more embodiments, other methods for generating testcases can be implemented and the test cases can be generated with avariable number of files and arguments for use during testing.

Next, in accordance with one or more embodiments, the test cases thatare generated are used to test a desired ABI of the operating system.

For example, according to one or more embodiments, the tester compileseach file into an object file, and links the main and target objectfiles together into an executable, so that the calls between them aregoverned by the ABI. The tester then runs each executable. For anyfunction call whose result does not match the result computed in main,the function name is printed, and the two sets of results are printed.

Further, according to one or more embodiments, the tester or automatictest system can regenerate test cases for each individual function thatis not correct, by specifying a seed corresponding to that functionname, and instructing the test case generator to generate a singlefunction test case. The tester/automatic test system validates that thesame failure is observed with the single test call.

Further, assuming the function still fails in the single call case, thetester can include additional processing that is able to reduce thearguments that the test case generator includes in the failed test casebased on a reduction algorithm as described herein. Specifically,processing is provided that iteratively runs the test case with somearguments withheld and if the test case continues to fail thosearguments can be omitted because they are not causing the failure.Accordingly, the process includes an omit portion that indicates whicharguments to omit, omits the arguments in a test case generated by thetest case generator, and repeats the process until the minimal set offailing arguments is found.

For example, according to one or more embodiments, the omit processprovides that each argument can be associated with a string ofcharacters. For example, the character can be either a “+” or a “−”. A +means that the argument in that position should be included, while a −means that the argument in that position should be excluded. If thestring contains fewer characters than the number of arguments generatedfor that function, all arguments beyond the last specified + or − areassumed to be included (i.e. “+”).

The terminology used herein is for the purpose of describing particularembodiments only and is not intended to be limiting. As used herein, thesingular forms “a”, “an” and “the” are intended to include the pluralforms as well, unless the context clearly indicates otherwise. It willbe further understood that the terms “comprises” and/or “comprising,”when used in this specification, specify the presence of statedfeatures, integers, steps, operations, elements, and/or components, butdo not preclude the presence or addition of one or more other features,integers, steps, operations, elements, components, and/or groupsthereof.

The corresponding structures, materials, acts, and equivalents of allmeans or step plus function elements in the claims below are intended toinclude any structure, material, or act for performing the function incombination with other claimed elements as specifically claimed. Thedescription has been presented for purposes of illustration anddescription, but is not intended to be exhaustive or limited to theembodiments in the form disclosed. Many modifications and variationswill be apparent to those of ordinary skill in the art without departingfrom the scope of the disclosure. The embodiments were chosen anddescribed in order to best explain the principles of the disclosure andthe practical application, and to enable others of ordinary skill in theart to understand various embodiments with various modifications as aresuited to the particular use contemplated.

The present embodiments may be a system, a method, and/or a computerprogram product at any possible technical detail level of integration.The computer program product may include a computer readable storagemedium (or media) having computer readable program instructions thereonfor causing a processor to carry out aspects of the present disclosure.

The computer readable storage medium can be a tangible device that canretain and store instructions for use by an instruction executiondevice. The computer readable storage medium may be, for example, but isnot limited to, an electronic storage device, a magnetic storage device,an optical storage device, an electromagnetic storage device, asemiconductor storage device, or any suitable combination of theforegoing. A non-exhaustive list of more specific examples of thecomputer readable storage medium includes the following: a portablecomputer diskette, a hard disk, a random access memory (RAM), aread-only memory (ROM), an erasable programmable read-only memory (EPROMor Flash memory), a static random access memory (SRAM), a portablecompact disc read-only memory (CD-ROM), a digital versatile disk (DVD),a memory stick, a floppy disk, a mechanically encoded device such aspunch-cards or raised structures in a groove having instructionsrecorded thereon, and any suitable combination of the foregoing. Acomputer readable storage medium, as used herein, is not to be construedas being transitory signals per se, such as radio waves or other freelypropagating electromagnetic waves, electromagnetic waves propagatingthrough a waveguide or other transmission media (e.g., light pulsespassing through a fiber-optic cable), or electrical signals transmittedthrough a wire.

Computer readable program instructions described herein can bedownloaded to computing/processing devices from a computer readablestorage medium or to an external computer or external storage device viaa network, for example, the Internet, a local area network, a wide areanetwork and/or a wireless network. The network may comprise coppertransmission cables, optical transmission fibers, wireless transmission,routers, firewalls, switches, gateway computers and/or edge servers. Anetwork adapter card or network interface in each computing/processingdevice receives computer readable program instructions from the networkand forwards the computer readable program instructions for storage in acomputer readable storage medium within the computing/processing device.

Computer readable program instructions for carrying out operations ofthe present disclosure may be assembler instructions,instruction-set-architecture (ISA) instructions, machine instructions,machine dependent instructions, microcode, firmware instructions,state-setting data, configuration data for integrated circuitry, oreither source code or object code written in any combination of one ormore programming languages, including an object oriented programminglanguage such as Java, Smalltalk, C++, or the like, and conventionalprocedural programming languages, such as the “C” programming languageor similar programming languages. The computer readable programinstructions may execute entirely on the user's computer, partly on theuser's computer, as a stand-alone software package, partly on the user'scomputer and partly on a remote computer or entirely on the remotecomputer or server. In the latter scenario, the remote computer may beconnected to the user's computer through any type of network, includinga local area network (LAN) or a wide area network (WAN), or theconnection may be made to an external computer (for example, through theInternet using an Internet Service Provider). In some embodiments,electronic circuitry including, for example, programmable logiccircuitry, field-programmable gate arrays (FPGA), or programmable logicarrays (PLA) may execute the computer readable program instructions byutilizing state information of the computer readable programinstructions to personalize the electronic circuitry, in order toperform aspects of the present disclosure.

Aspects of the present invention are described herein with reference toflowchart illustrations and/or block diagrams of methods, apparatus(systems), and computer program products according to embodiments. Itwill be understood that each block of the flowchart illustrations and/orblock diagrams, and combinations of blocks in the flowchartillustrations and/or block diagrams, can be implemented by computerreadable program instructions.

These computer readable program instructions may be provided to aprocessor of a general purpose computer, special purpose computer, orother programmable data processing apparatus to produce a machine, suchthat the instructions, which execute via the processor of the computeror other programmable data processing apparatus, create means forimplementing the functions/acts specified in the flowchart and/or blockdiagram block or blocks. These computer readable program instructionsmay also be stored in a computer readable storage medium that can directa computer, a programmable data processing apparatus, and/or otherdevices to function in a particular manner, such that the computerreadable storage medium having instructions stored therein comprises anarticle of manufacture including instructions which implement aspects ofthe function/act specified in the flowchart and/or block diagram blockor blocks.

The computer readable program instructions may also be loaded onto acomputer, other programmable data processing apparatus, or other deviceto cause a series of operational steps to be performed on the computer,other programmable apparatus or other device to produce a computerimplemented process, such that the instructions which execute on thecomputer, other programmable apparatus, or other device implement thefunctions/acts specified in the flowchart and/or block diagram block orblocks.

The flowchart and block diagrams in the Figures illustrate thearchitecture, functionality, and operation of possible implementationsof systems, methods, and computer program products according to variousembodiments. In this regard, each block in the flowchart or blockdiagrams may represent a module, segment, or portion of instructions,which comprises one or more executable instructions for implementing thespecified logical function(s). In some alternative implementations, thefunctions noted in the blocks may occur out of the order noted in theFigures. For example, two blocks shown in succession may, in fact, beexecuted substantially concurrently, or the blocks may sometimes beexecuted in the reverse order, depending upon the functionalityinvolved. It will also be noted that each block of the block diagramsand/or flowchart illustration, and combinations of blocks in the blockdiagrams and/or flowchart illustration, can be implemented by specialpurpose hardware-based systems that perform the specified functions oracts or carry out combinations of special purpose hardware and computerinstructions.

The descriptions of the various embodiments have been presented forpurposes of illustration, but are not intended to be exhaustive orlimited to the embodiments disclosed. Many modifications and variationswill be apparent to those of ordinary skill in the art without departingfrom the scope and spirit of the described embodiments. The terminologyused herein was chosen to best explain the principles of theembodiments, the practical application or technical improvement overtechnologies found in the marketplace, or to enable others of ordinaryskill in the art to understand the embodiments disclosed herein.

Accordingly, the present disclosure is not to be seen as limited by theforegoing description, but is only limited by the scope of the appendedclaims.

What is claimed is:
 1. A computer-implemented method of test casereduction in application binary interface (ABI) compatibility testing,the computer-implemented method including: receiving, from a memory at aprocessor, a failed test case and a plurality of arguments that were thecause of a failure of the failed test case; selecting, using theprocessor, a first subset of arguments from the plurality of arguments,wherein selecting the first subset of arguments from the plurality ofarguments comprises: defining a plurality of states of arguments,assigning each argument in the plurality of arguments a state, andselecting the first subset of arguments based on the state of eachargument; running, using the processor, a copy of the failed test casewithout the first subset of arguments; omitting, using the processor,the first subset of arguments from the copy of the failed test casebased on a determination that the copy of the failed test case continuesto fail; retaining, using the processor, the first subset of argumentsbased on a determination that the copy of the failed test case passesindicating that the first subset of arguments contain arguments thattrigger the failure; iteratively selecting, using the processor, aplurality of subsets of the plurality of arguments and omitting when thecopy of the failed test case continues to fail until all arguments inthe plurality of arguments have been screened; and storing, in thememory, the remaining plurality of arguments that has arguments omittedas a minimal set of arguments that cause the failure of the failed testcase.
 2. The computer-implemented method of claim 1, further comprising:generating, using the processor, a plurality of test cases that eachinclude a function call and a target function; generating, using theprocessor, a plurality of arguments for each of the plurality of testcases; executing, using the processor, each of the plurality of testcases using the plurality of arguments generated for that test case;detecting, using the processor, a set of failed test cases from theplurality of test cases; and selecting, using the processor, a failedtest case from the set of failed test cases.
 3. The computer-implementedmethod of claim 1, further comprising: generating the copy of the failedtest case based on a random number generator seeded by a seed value thatwas used to generate the failed test case initially.
 4. Thecomputer-implemented method of claim 3, further comprising: detecting arandomly generated failed test case; receiving the seed value of therandomly generated failed test case; regenerating the failed test caseusing the seed value; and storing the regenerated failed test case asthe copy of the failed test case in memory.
 5. The computer-implementedmethod of claim 1, wherein defining the plurality of states of argumentscomprises: defining an omit state wherein an argument is known not to berequired to produce a failure; defining an inclusive state wherein anargument is known to be required to produce a failure; defining a teststate wherein an argument in this state is to be tested as one possiblynot required to produce a test case failure; and defining an assumedinclusion state wherein an argument is assumed to be required to producea failure.
 6. The computer-implemented method of claim 5, whereindefining the plurality of states of arguments further comprises:representing the omit state by a first character; representing theinclusive state by a second character; representing the test state by athird character; and representing the assumed inclusion state by afourth character.
 7. A computer program product for test case reductionin application binary interface (ABI) compatibility testing, thecomputer program product comprising a computer readable storage mediumhaving program instructions embodied therewith, the program instructionsexecutable by a processor to cause the processor to: receive, from amemory at the processor, a failed test case and a plurality of argumentsthat were the cause of a failure of the failed test case; select, usingthe processor, a first subset of arguments from the plurality ofarguments, wherein select the first subset of arguments form theplurality of arguments using the processor to: define a plurality ofstates of arguments; assign each argument in the plurality of argumentsa state; and select the first subset of arguments based on the state ofeach argument; run, using the processor, a copy of the failed test casewithout the first subset of arguments; omit, using the processor, thefirst subset of arguments from the copy of the failed test case based ona determination that the copy of the failed test case continues to fail;retain, using the processor, the first subset of arguments based on adetermination that the copy of the failed test case passes indicatingthat the first subset of arguments contain arguments that trigger thefailure; iteratively select, using the processor, a plurality of subsetsof the plurality of arguments and omitting when the copy of the failedtest case continues to fail until all arguments in the plurality ofarguments have been screened; and store, in the memory, the remainingplurality of arguments that has arguments omitted as a minimal set ofarguments that cause the failure of the failed test case.
 8. Thecomputer program product of claim 7, the computer program productcomprising the computer readable storage medium having programinstructions embodied therewith, the program instructions executable bythe processor to cause the processor to: generate, using the processor,a plurality of test cases that each include a function call and a targetfunction; generate, using the processor, a plurality of arguments foreach of the plurality of test cases; execute, using the processor, eachof the plurality of test cases using the plurality of argumentsgenerated for that test case; detect, using the processor, a set offailed test cases from the plurality of test cases; and select, usingthe processor, a failed test case from the set of failed test cases. 9.The computer program product of claim 7, the computer program productcomprising the computer readable storage medium having programinstructions embodied therewith, the program instructions executable bythe processor to cause the processor to: generate the copy of the failedtest case based on a random number generator seeded by a seed value thatwas used to generate the failed test case initially.
 10. The computerprogram product of claim 9, the computer program product comprising thecomputer readable storage medium having program instructions embodiedtherewith, the program instructions executable by the processor to causethe processor to: detect a randomly generated failed test case; receivethe seed value of the randomly generated failed test case; regeneratethe failed test case using the seed value; and store the regeneratedfailed test case as the copy of the failed test case in memory.
 11. Thecomputer program product of claim 7, the computer program productcomprising the computer readable storage medium having programinstructions embodied therewith, the program instructions executable bythe processor to cause the processor to: define an omit state wherein anargument is known not to be required to produce a failure; define aninclusive state wherein an argument is known to be required to produce afailure; define a test state wherein an argument in this state is to betested as one possibly not required to produce a test case failure; anddefine an assumed inclusion state wherein an argument is assumed to berequired to produce a failure.
 12. The computer program product of claim11, the computer program product comprising the computer readablestorage medium having program instructions embodied therewith, theprogram instructions executable by the processor to cause the processorto: represent the omit state by a first character; represent theinclusive state by a second character; represent the test state by athird character; and represent the assumed inclusion state by a fourthcharacter.
 13. A system for test case reduction in application binaryinterface (ABI) compatibility testing, the system comprising: a memoryhaving computer readable instructions; and a processor configured toexecute the computer readable instructions, the computer readableinstructions comprising: receiving, from the memory at the processor, afailed test case and a plurality of arguments that were the cause of afailure of the failed test case; selecting, using the processor, a firstsubset of arguments from the plurality of arguments, wherein selectingthe first subset of arguments from the plurality of arguments comprises:defining a plurality of states of arguments, assigning each argument inthe plurality of arguments a state, and selecting the first subset ofarguments based on the state of each argument; running, using theprocessor, a copy of the failed test case without the first subset ofarguments; omitting, using the processor, the first subset of argumentsfrom the copy of the failed test case based on a determination that thecopy of the failed test case continues to fail; retaining, using theprocessor, the first subset of arguments based on a determination thatthe copy of the failed test case passes indicating that the first subsetof arguments contain arguments that trigger the failure; iterativelyselecting, using the processor, a plurality of subsets of the pluralityof arguments and omitting when the copy of the failed test casecontinues to fail until all arguments in the plurality of arguments havebeen screened; and storing, in the memory, the remaining plurality ofarguments that has arguments omitted as a minimal set of arguments thatcause the failure of the failed test case.
 14. The system of claim 13,the computer readable instructions further comprising: generating, usingthe processor, a plurality of test cases that each include a functioncall and a target function; generating, using the processor, a pluralityof arguments for each of the plurality of test cases; executing, usingthe processor, each of the plurality of test cases using the pluralityof arguments generated for that test case; detecting, using theprocessor, a set of failed test cases from the plurality of test cases;and selecting, using the processor, a failed test case from the set offailed test cases.
 15. The system of claim 13, the computer readableinstructions further comprising: generating the copy of the failed testcase based on a random number generator seeded by a seed value that wasused to generate the failed test case initially.
 16. The system of claim13, the computer readable instructions further comprising: detecting arandomly generated failed test case; receiving the seed value of therandomly generated failed test case; regenerating the failed test caseusing the seed value; and storing the regenerated failed test case asthe copy of the failed test case in memory.
 17. The system of claim 13,the computer readable instructions further comprising: defining an omitstate wherein an argument is known not to be required to produce afailure; defining an inclusive state wherein an argument is known to berequired to produce a failure; defining a test state wherein an argumentin this state is to be tested as one possibly not required to produce atest case failure; and defining an assumed inclusion state wherein anargument is assumed to be required to produce a failure.
 18. The systemof claim 13, the computer readable instructions further comprises:representing the omit state by a first character; representing theinclusive state by a second character; representing the test state by athird character; and representing the assumed inclusion state by afourth character.